import os
import json
import re
from pathlib import Path

import os
import json
import re
from pathlib import Path

def clean_text(text):
    """
    清理文本中的多余标记符
    """
    if not isinstance(text, str):
        return ""
    
    # 移除多余的标记符
    text = re.sub(r'\*{2,}', '', text)  # 移除多余的**
    text = re.sub(r'#{3,}', '', text)   # 移除多余的###
    text = re.sub(r'^\s*[:：]?\s*', '', text)  # 移除开头的标点
    text = re.sub(r'\s+', ' ', text)    # 合并多个空格为一个
    return text.strip()

def parse_question_content(question_text):
    """
    解析question字段内容，提取题目、选项、答案和解析
    """
    # 初始化结果
    result = {
        "scenario": "",
        "key_points": "",
        "question": "",
        "options": {},
        "answer": "",
        "explanation": ""
    }
    
    if not question_text or not isinstance(question_text, str):
        return result
    
    # 清理文本
    question_text = question_text.replace('\r\n', '\n').replace('\r', '\n')
    
    # 提取情境描述 - 支持多种格式
    scenario_patterns = [
        r'\*{2}情境描述\*{2}[:：]?\s*(.*?)(?=\*{2}关键观察点\*{2}|\*{2}问题\*{2}|#{3,}\s*关键观察点|#{3,}\s*问题|\n\s*\n)',
        r'#{3,}\s*情境描述[:：]?\s*(.*?)(?=\*{2}关键观察点\*{2}|\*{2}问题\*{2}|#{3,}\s*关键观察点|#{3,}\s*问题|\n\s*\n)',
        r'情境描述[:：]?\s*(.*?)(?=\*{2}关键观察点\*{2}|\*{2}问题\*{2}|#{3,}\s*关键观察点|#{3,}\s*问题|\n\s*\n)'
    ]
    
    for pattern in scenario_patterns:
        scenario_match = re.search(pattern, question_text, re.DOTALL)
        if scenario_match:
            result["scenario"] = clean_text(scenario_match.group(1))
            break
    
    # 提取关键观察点 - 支持多种格式
    key_points_patterns = [
        r'\*{2}关键观察点\*{2}[:：]?\s*(.*?)(?=\*{2}问题\*{2}|#{3,}\s*问题|\n\s*\n)',
        r'#{3,}\s*关键观察点[:：]?\s*(.*?)(?=\*{2}问题\*{2}|#{3,}\s*问题|\n\s*\n)',
        r'关键观察点[:：]?\s*(.*?)(?=\*{2}问题\*{2}|#{3,}\s*问题|\n\s*\n)'
    ]
    
    for pattern in key_points_patterns:
        key_points_match = re.search(pattern, question_text, re.DOTALL)
        if key_points_match:
            result["key_points"] = clean_text(key_points_match.group(1))
            break
    
    # 提取问题 - 支持多种格式
    question_patterns = [
        r'\*{2}问题\*{2}[:：]?\s*(.*?)(?=\*{2}选项\*{2}|#{3,}\s*选项|\n\s*\n)',
        r'#{3,}\s*问题[:：]?\s*(.*?)(?=\*{2}选项\*{2}|#{3,}\s*选项|\n\s*\n)',
        r'问题[:：]?\s*(.*?)(?=\*{2}选项\*{2}|#{3,}\s*选项|\n\s*\n)'
    ]
    
    for pattern in question_patterns:
        question_match = re.search(pattern, question_text, re.DOTALL)
        if question_match:
            result["question"] = clean_text(question_match.group(1))
            break
    
    # 提取选项 - 支持多种格式
    options_patterns = [
        r'\*{2}选项\*{2}[:：]?\s*(.*?)(?=\*{2}答案与解析\*{2}|\*{2}答案\*{2}|答案与解析|答案[:：]|\*{2}解析\*{2}|解析[:：]|$)',
        r'#{3,}\s*选项[:：]?\s*(.*?)(?=\*{2}答案与解析\*{2}|\*{2}答案\*{2}|答案与解析|答案[:：]|\*{2}解析\*{2}|解析[:：]|$)',
        r'选项[:：]?\s*(.*?)(?=\*{2}答案与解析\*{2}|\*{2}答案\*{2}|答案与解析|答案[:：]|\*{2}解析\*{2}|解析[:：]|$)'
    ]
    
    for pattern in options_patterns:
        options_match = re.search(pattern, question_text, re.DOTALL)
        if options_match:
            options_text = options_match.group(1).strip()
            # 提取选项A、B、C、D
            for option_letter in ['A', 'B', 'C', 'D']:
                # 支持多种选项格式
                option_patterns = [
                    rf'{option_letter}[\.、:\s]+([^\n]+)',
                    rf'{option_letter}\s*[:：]\s*([^\n]+)',
                    rf'{option_letter}[\.]\s*([^\n]+)'
                ]
                
                for opt_pattern in option_patterns:
                    option_match = re.search(opt_pattern, options_text)
                    if option_match:
                        result["options"][option_letter] = clean_text(option_match.group(1))
                        break
            break
    
    # 提取答案与解析 - 支持多种格式
    answer_section_patterns = [
        r'\*{2}答案与解析\*{2}[:：]?\s*(.*?)(?=$)',
        r'\*{2}答案\*{2}[:：]?\s*(.*?)(?=$)',
        r'答案与解析[:：]?\s*(.*?)(?=$)',
        r'答案[:：]?\s*(.*?)(?=$)'
    ]
    
    answer_text = ""
    for pattern in answer_section_patterns:
        answer_section_match = re.search(pattern, question_text, re.DOTALL)
        if answer_section_match:
            answer_text = answer_section_match.group(1).strip()
            break
    
    if answer_text:
        # 提取答案
        answer_patterns = [
            r'[正确]*答案[:：]?\s*([A-D])',
            r'正确答案[是为]?[:：]?\s*([A-D])'
        ]
        
        for pattern in answer_patterns:
            answer_match = re.search(pattern, answer_text)
            if answer_match:
                result["answer"] = answer_match.group(1)
                break
        
        # 提取解析
        explanation_patterns = [
            r'[解析解]释[:：]?\s*(.*?)(?=正确答案|$)',
            r'解析[:：]?\s*(.*?)(?=正确答案|$)',
            r'(?!.*答案)^.*'
        ]
        
        # 如果找到了答案位置，从答案后提取解析
        if result["answer"]:
            answer_pos_pattern = r'[正确]*答案[:：]?\s*' + result["answer"]
            answer_pos_match = re.search(answer_pos_pattern, answer_text)
            if answer_pos_match:
                explanation_text = answer_text[answer_pos_match.end():].strip()
                if explanation_text:
                    result["explanation"] = clean_text(explanation_text)
        else:
            # 如果没有明确的答案标识，尝试其他方式提取解析
            for pattern in explanation_patterns:
                explanation_match = re.search(pattern, answer_text, re.DOTALL)
                if explanation_match and explanation_match.group(1).strip():
                    result["explanation"] = clean_text(explanation_match.group(1))
                    break
    
    # 清理所有字段
    for key in result:
        if isinstance(result[key], str):
            # 移除多余的空白字符
            result[key] = re.sub(r'\s+', ' ', result[key].strip())
    
    return result

def process_json_files():
    """
    处理splitted_json目录下的所有JSON文件
    """
    # 创建输出目录
    output_dir = Path("parsed_questions")
    output_dir.mkdir(exist_ok=True)
    
    # 输入目录
    input_dir = Path("splitted_json")
    
    # 遍历所有JSON文件
    for json_file in input_dir.glob("*.json"):
        print(f"处理文件: {json_file}")
        
        # 读取JSON文件
        try:
            with open(json_file, 'r', encoding='utf-8') as f:
                data = json.load(f)
        except Exception as e:
            print(f"读取文件 {json_file} 失败: {e}")
            continue
        
        # 处理每个问题
        parsed_questions = []
        for item in data.get("questions", []):
            # 解析question字段
            try:
                parsed_question = parse_question_content(item.get("question", ""))
            except Exception as e:
                print(f"解析题目失败 (ID: {item.get('id', 'unknown')}): {e}")
                # 即使解析失败也保留原始内容
                parsed_question = {
                    "scenario": "",
                    "key_points": "",
                    "question": item.get("question", ""),
                    "options": {},
                    "answer": "",
                    "explanation": ""
                }
            
            # 添加其他字段
            parsed_question["id"] = item.get("id")
            parsed_question["scenario_type"] = item.get("scenario")
            parsed_question["dimension"] = item.get("dimension")
            parsed_question["complexity"] = item.get("complexity")
            parsed_question["success"] = item.get("success")
            
            parsed_questions.append(parsed_question)
        
        # 保存解析后的数据到新文件
        output_file = output_dir / json_file.name
        try:
            with open(output_file, 'w', encoding='utf-8') as f:
                json.dump(parsed_questions, f, ensure_ascii=False, indent=2)
            print(f"已保存: {output_file}")
        except Exception as e:
            print(f"保存文件 {output_file} 失败: {e}")

if __name__ == "__main__":
    process_json_files()
    print("所有文件处理完成！")